home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / Pascal / Snippets / PNL Libraries / MyDialogs.p < prev    next >
Encoding:
Text File  |  1997-06-13  |  34.2 KB  |  1,201 lines  |  [TEXT/CWIE]
  1. unit MyDialogs;
  2.  
  3. interface
  4.  
  5.     uses
  6.         Types, Quickdraw, Controls, Events, TextEdit, Windows, Dialogs, Menus,
  7.         MyUtils;
  8.  
  9.     const
  10.         i_ok = 1;
  11.         i_cancel = 2;
  12.         i_discard = 3;
  13.  
  14.     var
  15.         grey_pattern: PixPatHandle;
  16.  
  17.     var
  18.         shutup_talking_alerts: boolean;
  19.         gShutupTalkingAlertsModalFilterProc:UniversalProcPtr;
  20.         gStandardModalFilterProc:UniversalProcPtr;
  21.         gCancelModalFilterProc:UniversalProcPtr;
  22.         gDiscardModalFilterProc:UniversalProcPtr;
  23.         gOutlineDefault1Proc:UniversalProcPtr;
  24.         
  25.     procedure StartupDialogs;
  26.     procedure SetMyDialogFont(ft:MyFontType);
  27.     procedure EnterWindow (window: WindowPtr; ft:MyFontType; face: Style; var saved: SavedWindowInfo);
  28.     procedure ExitWindow (saved: SavedWindowInfo);
  29.     procedure ValidDItem( window: WindowPtr; item: integer );
  30.     procedure InvalDItem( window: WindowPtr; item: integer );
  31.     procedure SetItemText (window: DialogPtr; item: integer; text: Str255);
  32.     procedure GetItemText (window: DialogPtr; item: integer; var text: Str255);
  33.     function GetItemTextF (window: DialogPtr; item: integer): Str255;
  34.     procedure EraseDefault1(window: DialogPtr; item: integer);
  35.     procedure OutlineDefault1ForeBackground (window: DialogPtr; item: integer; foreground: Boolean);
  36.     procedure OutlineDefault1 (window: DialogPtr; item: integer);
  37.     procedure SetUpDefaultOutline(window: DialogPtr; def_item, user_item: integer; sethandler: Boolean);
  38.     procedure FlashDItem (window: DialogPtr; item: integer);
  39.     procedure SetDItemRect (window: DialogPtr; item: integer; rr: Rect);
  40.     procedure GetDItemRect (window: DialogPtr; item: integer; var rr: Rect);
  41.     procedure SetDItemKind (window: DialogPtr; item: integer; k: integer);
  42.     procedure GetDItemKind (window: DialogPtr; item: integer; var k: integer);
  43.     function IsControlDialogKind( kind: integer ): boolean;
  44.     procedure OffsetDItem( window: DialogPtr; item: integer; dh, dv: integer );
  45.     function GetDControlHandle (window: DialogPtr; item: integer): ControlHandle;
  46.     function GetDItemHandle (window: DialogPtr; item: integer): Handle;
  47. {    procedure SetDItemHandle (window: DialogPtr; item: integer; h: univ Handle);}
  48.     procedure SetUserItemProc (window: DialogPtr; item: integer; proc: UniversalProcPtr);
  49.     function GetDCtlEnable (window: DialogPtr; item: integer): boolean;
  50.     procedure SetDCtlEnable (window: DialogPtr; item: integer; on: boolean);
  51.     function GetDCtlTitle (window: DialogPtr; item: integer): Str255;
  52.     procedure SetDCtlTitle (window: DialogPtr; item: integer; s: Str255);
  53.     function GetDCtlBoolean (window: DialogPtr; item: integer): boolean;
  54.     procedure SetDCtlBoolean (window: DialogPtr; item: integer; value: boolean);
  55.     procedure ToggleDCtlBoolean (window: DialogPtr; item: integer);
  56.     function GetDCtlValue (window: DialogPtr; item: integer): integer;
  57.     procedure SetDCtlValue (window: DialogPtr; item: integer; value: integer);
  58.     function GetDCtlMax (window: DialogPtr; item: integer): integer;
  59.     procedure SetDCtlMax (window: DialogPtr; item: integer; value: integer);
  60.     function GetDCtlMin (window: DialogPtr; item: integer): integer;
  61.     procedure SetDCtlMin (window: DialogPtr; item: integer; value: integer);
  62.     function GetDCtlHilite (window: DialogPtr; item: integer): integer;
  63.     procedure SetDCtlHilite (window: DialogPtr; item: integer; hilite: integer);
  64.     procedure DrawDItem (window: DialogPtr; item: integer);
  65.     function GetPopupMHandle (window: DialogPtr; item: integer): MenuHandle;
  66.     procedure SetPopUpMenuOnMouseDown (window: DialogPtr; item: integer; text: Str255);
  67.     procedure GetPopUpItemText (window: DialogPtr; item: integer; var text: Str255);
  68.     procedure SetWindowTitle (window: WindowPtr; title: Str255);
  69.     function SelectedTextItem (window: DialogPtr): integer;
  70.     procedure SelectDialogItem(window: DialogPtr; item: integer);
  71.     procedure GetDialogTextSelection(window: DialogPtr; var item, start, fin: integer);
  72.     procedure DrawTheFriggingGrowIcon (window: WindowPtr; bounds: Rect);
  73.     procedure DisplayStyledString (window: DialogPtr; item: integer; s: Str255; selected: boolean);
  74. { s= "font:size:style:just:text" }
  75.     procedure DrawStyledTextUserItem( window: DialogPtr; item: integer; ft: MyFontType; face: Style; const data: Str255 );
  76.     procedure ShiftTab (window: DialogPtr);
  77.     procedure ManualTab (window: DialogPtr; shift: boolean);
  78.     function CountDItems (window: DialogPtr): integer;
  79.     procedure DrawGrayRect (window: DialogPtr; item: integer; title: Str255);
  80.     procedure SetDialogTextFont (window: DialogPtr; ft:MyFontType; face: Style);
  81.     function ShutupTalkingAlertsModalFilter (window: DialogPtr; var event: EventRecord; var item: integer): boolean;
  82.     function StandardModalFilter (window: DialogPtr; var er: EventRecord; var item: integer): boolean;
  83.     function CancelModalFilter (window: DialogPtr; var er: EventRecord; var item: integer): boolean;
  84.     function DiscardModalFilter (window: DialogPtr; var er: EventRecord; var item: integer): boolean;
  85.     function TrackItems(window:WindowPtr; i1,i2,i3:integer):boolean;
  86.     function PointOverEditTextItem( window: WindowPtr; localwhere: Point ): integer;
  87.     function OverEditTextItem: Boolean;
  88.     procedure StyleTextBox( text: Handle; styles: StScrpHandle; var box: Rect; just: integer);
  89.     procedure DialogGetTextDropInformation( window: DialogPtr; localwhere: Point; var field: integer; var offset: integer; hilite: RgnHandle; invert: RgnHandle );
  90. {    procedure GetDAFont (var font: integer);  -- use LMGetDlgFont }
  91.     procedure PenPatGray;
  92.     procedure SafePlotCIcon( id: integer; const frame: Rect; selected: boolean );
  93.  
  94. implementation
  95.  
  96.     uses
  97.         QuickdrawText, Fonts, Memory, Palettes, OSUtils, TextUtils, Icons, Resources, 
  98.         MyTypes, MyStrings, MyUtils, MyMemory, MySystemGlobals, MyStartup, MyMathUtils, MyLowLevel, 
  99.         MyEvents, MyAssertions;
  100.         
  101. {$ifc do_debug}
  102.     var
  103.         startup_check: integer;
  104. {$endc}
  105.  
  106.     var
  107.         gOutlineDeviceLoopProc:UniversalProcPtr;
  108.     
  109. {$ifc not do_debug}
  110. {$definec AssertValidDialogItem(w,i)}
  111. {$definec AssertValidDialogControl(w,i)}
  112. {$elsec}
  113. {$definec AssertValidDialogItem(w,i) AssertValidDialogItemCode(w,i)}
  114. {$definec AssertValidDialogControl(w,i) AssertValidDialogControlCode(w,i)}
  115. {$endc}
  116.  
  117.     procedure AssertValidDialogItemCode( window: DialogPtr; item: integer );
  118.     begin
  119.         AssertDidStartup( startup_check );
  120.         Assert( (window <> nil) & (0 < item) & (item <= CountDItems(window)) );
  121.     end;
  122.     
  123.     function IsControlDialogKind( kind: integer ): boolean;
  124.     begin
  125.         IsControlDialogKind := band( kind, GoodBNOT(itemDisable) ) in 
  126.                 [kButtonDialogItem, kCheckBoxDialogItem, kRadioButtonDialogItem, kResourceControlDialogItem]
  127.     end;
  128.     
  129.     procedure AssertValidDialogControlCode( window: DialogPtr; item: integer );
  130.         var
  131.             kind: integer;
  132.             ih: Handle;
  133.             box: Rect;
  134.     begin
  135.         AssertValidDialogItemCode( window, item );
  136.         GetDialogItem( window, item, kind, ih, box );
  137.         Assert( IsControlDialogKind( kind ) );
  138.     end;
  139.     
  140.     procedure PenPatGray;
  141.     begin
  142.         AssertDidStartup( startup_check );
  143.         if grey_pattern = nil then begin
  144.             PenPat(GetQDGlobals^.gray);
  145.         end else begin
  146.             PenPixPat(grey_pattern);
  147.         end;
  148.     end;
  149.  
  150.     procedure ValidDItem( window: WindowPtr; item: integer );
  151.         var
  152.             frame: Rect;
  153.     begin
  154.         AssertValidDialogItem( window, item );
  155.         GetDItemRect( window, item, frame );
  156.         ValidRect( frame );
  157.     end;
  158.     
  159.     procedure InvalDItem( window: WindowPtr; item: integer );
  160.         var
  161.             frame: Rect;
  162.     begin
  163.         AssertValidDialogItem( window, item );
  164.         GetDItemRect( window, item, frame );
  165.         InvalRect( frame );
  166.     end;
  167.     
  168.     procedure SetItemText (window: DialogPtr; item: integer; text: Str255);
  169.         var
  170.             kind: integer;
  171.             ih: Handle;
  172.             box: Rect;
  173.             oldtext: Str255;
  174.     begin
  175.         AssertValidDialogItem( window, item );
  176.         GetDialogItem(window, item, kind, ih, box);
  177.         Assert( (band(kind,GoodBNOT(itemDisable)) in [statText, editText]) );
  178.         GetDialogItemText(ih, oldtext);
  179.         if oldtext <> text then begin
  180.             SetDialogItemText(ih, text);
  181.         end;
  182.     end;
  183.  
  184.     procedure GetItemText (window: DialogPtr; item: integer; var text: Str255);
  185.         var
  186.             kind: integer;
  187.             ih: Handle;
  188.             box: Rect;
  189.     begin
  190.         AssertValidDialogItem( window, item );
  191.         GetDialogItem(window, item, kind, ih, box);
  192.         Assert( (band(kind,GoodBNOT(itemDisable)) in [statText, editText]) );
  193.         GetDialogItemText(ih, text);
  194.     end;
  195.  
  196.     function GetItemTextF (window: DialogPtr; item: integer): Str255;
  197.         var
  198.             text: Str255;
  199.     begin
  200.         AssertValidDialogItem( window, item );
  201.         GetItemText(window, item, text);
  202.         GetItemTextF := text;
  203.     end;
  204.  
  205.     var
  206.         gODRect:Rect;
  207.         gODEnabled:Boolean;
  208.         
  209.     procedure OutlineDeviceLoop (depth: integer; deviceFlags: integer; targetDevice: GDHandle; ignore:longint);
  210.         var
  211.             backGround,foreGround:RGBColor;
  212.             dummy:boolean;
  213.     begin
  214. {$unused(deviceFlags, ignore)}
  215.         if not gODEnabled then begin
  216.             if depth=1 then begin
  217.                 PenPat(GetQDGlobals^.gray);
  218.             end else begin
  219.                 MakeRGBColor($0000,$0000,$0000,backGround);
  220.                 MakeRGBColor($0000FFFF,$0000FFFF,$0000FFFF,foreGround);
  221.                 dummy:=GetGray(targetDevice,backGround,foreGround);
  222.                 RGBForeColor(foreGround);
  223.             end;
  224.         end;
  225.         FrameRoundRect(gODRect, 16, 16);
  226.         PenPat(GetQDGlobals^.black);
  227.         ForeColor(blackColor);
  228.     end;
  229.     
  230.     procedure EraseDefault1(window: DialogPtr; item: integer);
  231.     begin
  232.         AssertValidDialogItem( window, item );
  233.         SetPort( window );
  234.         GetDItemRect( window, item, gODRect );
  235.         InsetRect( gODRect, 2, 2 );
  236.         PenSize( 3, 3 );
  237.         ForeColor( whiteColor );
  238.         FrameRoundRect( gODRect, 16, 16 );
  239.         ForeColor( blackColor );
  240.         PenNormal;
  241.     end;
  242.     
  243.     procedure OutlineDefault1ForeBackground(window: DialogPtr; item: integer; foreground: Boolean);
  244. {$ifc do_debug}
  245.         var
  246.             kind: integer;
  247. {$endc}
  248.     begin
  249. {$ifc do_debug}
  250.         AssertValidDialogItem( window, item );
  251.         GetDItemKind( window, item, kind );
  252.         Assert( band(kind,GoodBNOT(itemDisable)) = userItem );
  253. {$endc}
  254.         SetPort(window);
  255.         GetDItemRect(window, item, gODRect);
  256.         InsetRect(gODRect, 2, 2);
  257.         gODEnabled := GetDCtlEnable(window, 1) & (FrontWindow = window) & foreground;
  258.         PenSize(3, 3);
  259.         SafeDeviceLoopRect(gODRect, gOutlineDeviceLoopProc, 0, 0);
  260.         PenNormal;
  261.     end;
  262.  
  263.     procedure OutlineDefault1(window: DialogPtr; item: integer);
  264.     begin
  265.         OutlineDefault1ForeBackground( window, item, InForeground );
  266.     end;
  267.  
  268.     procedure SetUpDefaultOutline(window: DialogPtr; def_item, user_item: integer; sethandler: Boolean);
  269.         var
  270.             box: Rect;
  271. {$ifc do_debug}
  272.             kind: integer;
  273. {$endc}
  274.     begin
  275. {$ifc do_debug}
  276.         Assert( def_item = 1 ); { must be 1 for GetDCtlEnable(window, 1) in OutlineDefault1ForeBackground }
  277.         AssertValidDialogItem( window, def_item );
  278.         AssertValidDialogItem( window, user_item );
  279.         GetDItemKind( window, def_item, kind );
  280.         Assert( band(kind,GoodBNOT(itemDisable)) = ctrlItem + btnCtrl );
  281.         GetDItemKind( window, user_item, kind );
  282.         Assert( band(kind,GoodBNOT(itemDisable)) = userItem );
  283.         Assert( gOutlineDefault1Proc <> nil );
  284. {$endc}
  285.         GetDItemRect( window, def_item, box);
  286.         InsetRect( box, -6,-6 );
  287.         SetDItemRect( window, user_item, box );
  288.         if sethandler then begin
  289.             SetUserItemProc( window, user_item, gOutlineDefault1Proc );
  290.         end;
  291.     end;
  292.  
  293.     procedure FlashDItem(window: DialogPtr; item: integer);
  294.         var
  295.             f: longint;
  296.     begin
  297.         AssertValidDialogControl( window, item );
  298.         SetDCtlHilite(window, item, kControlButtonPart);
  299.         Delay(2, f);
  300.         SetDCtlHilite(window, item, 0);
  301.     end;
  302.  
  303.     procedure SetDItemRect (window: DialogPtr; item: integer; rr: Rect);
  304.         var
  305.             kind: integer;
  306.             h: Handle;
  307.             r: Rect;
  308.     begin
  309.         AssertValidDialogItem( window, item );
  310.         GetDialogItem(window, item, kind, h, r);
  311.         SetDialogItem(window, item, kind, h, rr);
  312.     end;
  313.  
  314.     procedure GetDItemRect (window: DialogPtr; item: integer; var rr: Rect);
  315.         var
  316.             kind: integer;
  317.             h: Handle;
  318.     begin
  319.         AssertValidDialogItem( window, item );
  320.         GetDialogItem(window, item, kind, h, rr);
  321.     end;
  322.  
  323.     procedure SetDItemKind (window: DialogPtr; item: integer; k: integer);
  324.         var
  325.             kk: integer;
  326.             h: Handle;
  327.             r: Rect;
  328.     begin
  329.         AssertValidDialogItem( window, item );
  330.         GetDialogItem(window, item, kk, h, r);
  331.         SetDialogItem(window, item, k, h, r);
  332.     end;
  333.  
  334.     procedure GetDItemKind (window: DialogPtr; item: integer; var k: integer);
  335.         var
  336.             r: Rect;
  337.             h: Handle;
  338.     begin
  339.         GetDialogItem(window, item, k, h, r);
  340.     end;
  341.  
  342.     procedure OffsetDItem( window: DialogPtr; item: integer; dh, dv: integer );
  343.         var
  344.             kind: integer;
  345.             data: Handle;
  346.             r: Rect;
  347.     begin
  348.         AssertValidDialogItem( window, item );
  349.         GetDialogItem( window, item, kind, data, r );
  350.         OffsetRect( r, dh, dv );
  351.         SetDialogItem( window, item, kind, data, r );
  352.         if IsControlDialogKind( kind ) then begin
  353.             MoveControl( ControlHandle( data ), r.left, r.top );
  354.         end;
  355.     end;
  356.     
  357.     function GetDControlHandle (window: DialogPtr; item: integer): ControlHandle;
  358.     begin
  359.         AssertValidDialogControlCode( window, item );
  360.         GetDControlHandle := ControlHandle(GetDItemHandle(window, item));
  361.     end;
  362.  
  363.     function GetDItemHandle (window: DialogPtr; item: integer): Handle;
  364.         var
  365.             kind: integer;
  366.             h: Handle;
  367.             r: Rect;
  368.     begin
  369.         AssertValidDialogItem( window, item );
  370.         GetDialogItem(window, item, kind, h, r);
  371.         GetDItemHandle := h;
  372.     end;
  373.  
  374.     procedure SetDItemHandle (window: DialogPtr; item: integer; h: univ Handle);
  375.         var
  376.             kind: integer;
  377.             hh: Handle;
  378.             r: Rect;
  379.     begin
  380.         AssertValidDialogItem( window, item );
  381.         GetDialogItem(window, item, kind, hh, r);
  382.         SetDialogItem(window, item, kind, h, r);
  383.     end;
  384.  
  385.     procedure SetUserItemProc (window: DialogPtr; item: integer; proc: UniversalProcPtr);
  386.         var
  387.             kind: integer;
  388.             hh: Handle;
  389.             r: Rect;
  390.     begin
  391.         Assert( proc <> nil );
  392.         AssertValidDialogItem( window, item );
  393.         GetDialogItem(window, item, kind, hh, r);
  394.         Assert( band(kind,GoodBNOT(itemDisable)) = userItem );
  395.         SetDialogItem(window, item, kind, Handle(proc), r);
  396.     end;
  397.     
  398.     function GetDCtlHilite (window: DialogPtr; item: integer): integer;
  399.     begin
  400.         AssertValidDialogControlCode( window, item );
  401.         GetDCtlHilite := ControlHandle(GetDItemHandle(window, item))^^.contrlHilite;
  402.     end;
  403.  
  404.     procedure SetDCtlHilite (window: DialogPtr; item: integer; hilite: integer);
  405.         var
  406.             ch: ControlHandle;
  407.     begin
  408.         AssertValidDialogControlCode( window, item );
  409.         ch := ControlHandle(GetDItemHandle(window, item));
  410.         if ch^^.contrlHilite <> hilite then begin
  411.             HiliteControl(ch, hilite);
  412.         end;
  413.     end;
  414.  
  415.     function GetDCtlEnable (window: DialogPtr; item: integer): boolean;
  416.     begin
  417.         AssertValidDialogControlCode( window, item );
  418.         GetDCtlEnable := GetDCtlHilite(window, item) <> 255;
  419.     end;
  420.  
  421.     procedure SetDCtlEnable (window: DialogPtr; item: integer; on: boolean);
  422.     begin
  423.         AssertValidDialogControlCode( window, item );
  424.         SetDCtlHilite(window, item, 255 * ord(not on))
  425.     end;
  426.  
  427.     function GetDCtlTitle (window: DialogPtr; item: integer): Str255;
  428.         var
  429.             s: Str255;
  430.     begin
  431.         GetControlTitle(GetDControlHandle(window, item), s);
  432.         GetDCtlTitle := s;
  433.     end;
  434.  
  435.     procedure SetDCtlTitle (window: DialogPtr; item: integer; s: Str255);
  436.         var
  437.             ch: ControlHandle;
  438.             old: Str255;
  439.     begin
  440.         ch := GetDControlHandle(window, item);
  441.         GetControlTitle(ch, old);
  442.         if old <> s then begin
  443.             SetControlTitle(ch, s);
  444.         end;
  445.     end;
  446.  
  447.     function GetDCtlBoolean (window: DialogPtr; item: integer): boolean;
  448.     begin
  449.         GetDCtlBoolean := GetControlValue(GetDControlHandle(window, item)) <> 0;
  450.     end;
  451.  
  452.     procedure SetDCtlBoolean (window: DialogPtr; item: integer; value: boolean);
  453.     begin
  454.         SetControlValue(GetDControlHandle(window, item), ord(value));
  455.     end;
  456.  
  457.     procedure ToggleDCtlBoolean (window: DialogPtr; item: integer);
  458.     begin
  459.         SetDCtlBoolean(window, item, not GetDCtlBoolean(window, item));
  460.     end;
  461.  
  462.     function GetDCtlValue (window: DialogPtr; item: integer): integer;
  463.     begin
  464.         GetDCtlValue := GetControlValue(GetDControlHandle(window, item));
  465.     end;
  466.  
  467.     procedure SetDCtlValue (window: DialogPtr; item: integer; value: integer);
  468.     begin
  469.         SetControlValue(GetDControlHandle(window, item), value);
  470.     end;
  471.  
  472.     function GetDCtlMax (window: DialogPtr; item: integer): integer;
  473.     begin
  474.         GetDCtlMax := GetControlMaximum(GetDControlHandle(window, item));
  475.     end;
  476.  
  477.     procedure SetDCtlMax (window: DialogPtr; item: integer; value: integer);
  478.     begin
  479.         SetControlMaximum(GetDControlHandle(window, item), value);
  480.     end;
  481.  
  482.     function GetDCtlMin (window: DialogPtr; item: integer): integer;
  483.     begin
  484.         GetDCtlMin := GetControlMinimum(GetDControlHandle(window, item));
  485.     end;
  486.  
  487.     procedure SetDCtlMin (window: DialogPtr; item: integer; value: integer);
  488.     begin
  489.         SetControlMinimum(GetDControlHandle(window, item), value);
  490.     end;
  491.  
  492.     procedure DrawDItem (window: DialogPtr; item: integer);
  493.     begin
  494.         Draw1Control(GetDControlHandle(window, item));
  495.     end;
  496.  
  497.     function GetPopupMHandle (window: DialogPtr; item: integer): MenuHandle;
  498.         type
  499.             MenuHandlePtr = ^MenuHandle;
  500.             MenuHandleHandle = ^MenuHandlePtr;
  501.     begin
  502.         GetPopupMHandle := MenuHandleHandle(GetDControlHandle(window, item)^^.contrlData)^^;
  503.     end;
  504.  
  505.     procedure SetPopUpMenuOnMouseDown (window: DialogPtr; item: integer; text: Str255);
  506.         var
  507.             mh: MenuHandle;
  508.             i, index: integer;
  509.             s: Str255;
  510.     begin
  511.         mh := GetPopupMHandle(window, item);
  512.         if text = '' then begin
  513.             GetMenuItemText(mh, 1, text);
  514.         end;
  515.         GetMenuItemText(mh, 2, s);
  516.         if s = '-' then begin
  517.             DeleteMenuItem(mh, 2);
  518.             DeleteMenuItem(mh, 1);
  519.         end;
  520.         index := 0;
  521.         for i := 1 to CountMItems(mh) do begin
  522.             GetMenuItemText(mh, i, s);
  523.             if (IUEqualString(s, text) = 0) then begin
  524.                 index := i;
  525.                 leave;
  526.             end;
  527.         end;
  528.         if index = 0 then begin
  529.             InsertMenuItem(mh, '(-;fred', 0);
  530.             SetMenuItemText(mh, 1, text);
  531.             index := 1;
  532.         end;
  533.         SetDCtlValue(window, item, index);
  534.     end;
  535.  
  536.     procedure GetPopUpItemText (window: DialogPtr; item: integer; var text: Str255);
  537.         var
  538.             mh: MenuHandle;
  539.     begin
  540.         mh := GetPopupMHandle(window, item);
  541.         GetMenuItemText(GetPopupMHandle(window, item), GetDCtlValue(window, item), text);
  542.     end;
  543.  
  544.     procedure SetWindowTitle (window: WindowPtr; title: Str255);
  545.         var
  546.             s: Str255;
  547.     begin
  548.         Assert( window <> nil );
  549.         GetWTitle(window, s);
  550.         if s <> title then begin
  551.             SetWTitle(window, title);
  552.         end;
  553.     end;
  554.  
  555.     function SelectedTextItem (window: DialogPtr): integer;
  556.     begin
  557.         Assert( window <> nil );
  558.         SelectedTextItem := DialogPeek(window)^.editField + 1;
  559.     end;
  560.  
  561.     procedure SelectDialogItem(window: DialogPtr; item: integer);
  562.     begin
  563.         AssertValidDialogItem( window, item );
  564.         SelectDialogItemText(window, item, 0, maxint);
  565.     end;
  566.     
  567.     procedure GetDialogTextSelection(window: DialogPtr; var item, start, fin: integer);
  568.     begin
  569.         Assert( window <> nil );
  570.         item := SelectedTextItem( window );
  571.         if item > 0 then begin
  572.             start := DialogPeek(window)^.textH^^.selStart;
  573.             fin := DialogPeek(window)^.textH^^.selEnd;
  574.         end else begin
  575.             start := -1;
  576.             fin := -1;
  577.         end;
  578.         if item > 0 then begin
  579.             AssertValidDialogItem( window, item );
  580.         end;
  581.     end;
  582.     
  583.     function CountDItems (window: DialogPtr): integer;
  584.     begin
  585.         Assert( window <> nil );
  586. {    count := CountDITL(window);}
  587.         CountDItems := integerH(DialogPeek(window)^.items)^^ + 1;
  588.     end;
  589.  
  590.     procedure ManualTab (window: DialogPtr; shift: boolean);
  591.         var
  592.             orgitem, i, count: integer;
  593.             k: integer;
  594.     begin
  595.         Assert( window <> nil );
  596.         orgitem := SelectedTextItem(window);
  597.         count := CountDItems(window);
  598.         if (orgitem > 0) & (count > 1) then begin
  599.             i := orgitem;
  600.             repeat
  601.                 if shift then begin
  602.                     i := i - 1;
  603.                     if i = 0 then begin
  604.                         i := count;
  605.                     end;
  606.                 end else begin
  607.                     i := i + 1;
  608.                     if i > count then begin
  609.                         i := 1;
  610.                     end;
  611.                 end;
  612.                 GetDItemKind(window, i, k);
  613.             until (i = orgitem) | (k = editText);
  614.         end;
  615.         GetDItemKind(window, i, k);
  616.         if k = editText then begin
  617.             SelectDialogItem(window, i);
  618.         end;
  619.     end;
  620.  
  621.     procedure ShiftTab (window: DialogPtr);
  622.         var
  623.             orgitem, i, count: integer;
  624.             k: integer;
  625.     begin
  626.         Assert( window <> nil );
  627.         orgitem := SelectedTextItem(window);
  628.         count := CountDItems(window);
  629.         if (orgitem > 0) & (count > 1) then begin
  630.             i := orgitem;
  631.             repeat
  632.                 i := i - 1;
  633.                 if i = 0 then begin
  634.                     i := count;
  635.                 end;
  636.                 GetDItemKind(window, i, k);
  637.             until (i = orgitem) | (k = editText);
  638.         end;
  639.         GetDItemKind(window, i, k);
  640.         if k = editText then begin
  641.             SelectDialogItem(window, i);
  642.         end;
  643.     end;
  644.  
  645.     procedure DrawTheFriggingGrowIcon (window: WindowPtr; bounds: Rect);
  646.         var
  647.             clip: RgnHandle;
  648.     begin
  649.         Assert( window <> nil );
  650.         SetPort(window);
  651.         PenNormal;
  652.         clip := NewRgn;
  653.         GetClip(clip);
  654.         ClipRect(bounds);
  655.         DrawGrowIcon(window);
  656.         SetClip(clip);
  657.         DisposeRgn(clip);
  658.     end;
  659.  
  660.     function DoButtonKey(window:DialogPtr; item:integer; var er: EventRecord; var item_hit:integer):boolean;
  661.     begin
  662.         if GetDCtlEnable(window,item) then begin
  663.             FlashDItem(window, item);
  664.             item_hit:=item;
  665.             DoButtonKey := true;
  666.         end else begin
  667.             SysBeep(10);
  668.             er.what:=nullEvent;
  669.             DoButtonKey := false;
  670.         end;
  671.     end;
  672.     
  673.     procedure PostMouseDown( window: WindowPtr );
  674.         var
  675.             structRgn: RgnHandle;
  676.             structRect: Rect;
  677.             where: Point;
  678.             err: OSErr;
  679.             event: EvQElPtr;
  680.     begin
  681.         SetPort( window );
  682.         structRgn := WindowPeek(window)^.strucRgn;
  683.         if structRgn <> nil then begin
  684.             structRect := structRgn^^.rgnBBox;
  685.         end;
  686.         where.h := (structRect.right + structRect.left) div 2;
  687.         where.v := structRect.top + 1;
  688.         err := PPostEvent( mouseDown, 0, event );
  689.         if err = noErr then begin
  690.             event^.evtQWhere := where;
  691.         end;
  692.     end;
  693.  
  694.     function ShutupTalkingAlertsModalFilter (window: DialogPtr; var event: EventRecord; var item: integer): boolean;
  695.     begin
  696. {$unused( item )}
  697.         if (event.what = updateEvt) & shutup_talking_alerts then begin
  698.             PostMouseDown( window );
  699.             shutup_talking_alerts := false;
  700.         end;
  701.         ShutupTalkingAlertsModalFilter := false;
  702.     end;
  703.  
  704.     function StandardModalFilter (window: DialogPtr; var er: EventRecord; var item: integer): boolean;
  705.     begin
  706.         Assert( window <> nil );
  707.         StandardModalFilter := false;
  708.         if ShutupTalkingAlertsModalFilter( window, er, item ) then begin
  709.             StandardModalFilter := true;
  710.         end else if EventIsKeyDown( er ) & EventHasOK( er ) then begin
  711.             StandardModalFilter:= DoButtonKey(window, i_ok, er, item);
  712.         end;
  713.     end;
  714.  
  715.     function CancelModalFilter (window: DialogPtr; var er: EventRecord; var item: integer): boolean;
  716.     begin
  717.         Assert( window <> nil );
  718.         CancelModalFilter := false;
  719.         if StandardModalFilter(window, er, item) then begin
  720.             CancelModalFilter := true;
  721.         end else if EventIsKeyDown( er ) & EventHasCancel( er ) then begin
  722.             CancelModalFilter:= DoButtonKey(window, i_cancel, er, item);
  723.         end;
  724.     end;
  725.  
  726.     function DiscardModalFilter (window: DialogPtr; var er: EventRecord; var item: integer): boolean;
  727.     begin
  728.         Assert( window <> nil );
  729.         DiscardModalFilter := false;
  730.         if CancelModalFilter(window, er, item) then begin
  731.             DiscardModalFilter := true;
  732.         end else if EventIsKeyDown( er ) & EventHasDiscard( er ) then begin
  733.             DiscardModalFilter:= DoButtonKey(window, i_discard, er, item);
  734.         end;
  735.     end;
  736.  
  737.     procedure SetMyDialogFont(ft:MyFontType);
  738.         var
  739.             font, size:integer;
  740.     begin
  741.         AssertDidStartup( startup_check );
  742.         GetMyFonts(ft, font, size);
  743.         SetDialogFont(font);
  744.     end;
  745.  
  746.     procedure EnterWindow (window: WindowPtr; ft:MyFontType; face: Style; var saved: SavedWindowInfo);
  747.     begin
  748.         AssertDidStartup( startup_check );
  749.         Assert( window <> nil );
  750.         GetPort(saved.oldport);
  751.         SetPort(window);
  752.         saved.thisport := window;
  753.         saved.font := window^.txFont;
  754.         saved.size := window^.txSize;
  755.         saved.face := window^.txFace;
  756.         SetMyFont(ft);
  757.         TextFace(face);
  758.         Assert( saved.thisport <> nil );
  759.     end;
  760.  
  761.     procedure ExitWindow (saved: SavedWindowInfo);
  762.     begin
  763.         Assert( saved.thisport <> nil );
  764.         SetPort(saved.thisport);
  765.         TextFont(saved.font);
  766.         TextSize(saved.size);
  767.         TextFace(saved.face);
  768.         SetPort(saved.oldport);
  769.     end;
  770.  
  771.     procedure SetDialogTextFont (window: DialogPtr; ft:MyFontType; face: Style);
  772.         var
  773.             saved: SavedWindowInfo;
  774.             fi: FontInfo;
  775.             te: TEHandle;
  776.             font, size: integer;
  777.     begin
  778.         EnterWindow(window, ft, face, saved);
  779.         GetFontInfo(fi);
  780.         GetMyFonts(ft, font, size);
  781.         te := DialogPeek(window)^.textH;
  782.         te^^.txFont := font;
  783.         te^^.txSize := size;
  784.         te^^.txFace := face;
  785.         te^^.lineHeight := fi.ascent + fi.descent + fi.leading;
  786.         te^^.fontAscent := fi.ascent;
  787.         TECalText(te);
  788.         ExitWindow(saved);
  789.     end;
  790.  
  791.     procedure DrawGrayRect (window: DialogPtr; item: integer; title: Str255);
  792.         const
  793.             left_indent = 20;
  794.             gap = 2;
  795.         var
  796.             r, er: Rect;
  797.             fi: FontInfo;
  798.             sw: integer;
  799.             saved: SavedWindowInfo;
  800.     begin
  801.         EnterWindow(window, MFT_Geneva9, [], saved);
  802.         GetDItemRect(window, item, r);
  803.         GetFontInfo(fi);
  804.         MoveTo(r.left + left_indent, r.top + fi.ascent);
  805.         sw := StringWidth(title);
  806.         er.top := r.top;
  807.         er.bottom := er.top + fi.ascent + fi.descent;
  808.         er.left := r.left + left_indent;
  809.         er.right := er.left + sw;
  810.         EraseRect(er);
  811.         DrawString(title);
  812.         PenPatGray;
  813.         r.top := r.top + (fi.ascent) div 2;
  814.         MoveTo(er.left - gap, r.top);
  815.         LineTo(r.left, r.top);
  816.         LineTo(r.left, r.bottom);
  817.         LineTo(r.right, r.bottom);
  818.         LineTo(r.right, r.top);
  819.         LineTo(er.right + gap, r.top);
  820.         PenNormal;
  821.         ExitWindow(saved);
  822.     end;
  823.  
  824.     function TrackItems(window:WindowPtr; i1,i2,i3:integer):boolean;
  825.         var
  826.             rgn:RgnHandle;
  827.         procedure AddItem(i:integer);
  828.             var
  829.                 itemrect:Rect;
  830.                 tmp:RgnHandle;
  831.         begin
  832.             if i <> 0 then begin
  833.                 GetDItemRect(window,i,itemrect);
  834.                 tmp := NewRgn;
  835.                 RectRgn(tmp, itemrect);
  836.                 UnionRgn(rgn, tmp, rgn);
  837.                 DisposeRgn(tmp);
  838.             end;
  839.         end;
  840.         var
  841.             inside,newinside:boolean;
  842.             mouse:Point;
  843.     begin
  844.         Assert( window <> nil );
  845.         rgn := NewRgn;
  846.         AddItem(i1);
  847.         AddItem(i2);
  848.         AddItem(i3);
  849.         InvertRgn(rgn);
  850.         inside:=true;
  851.         while StillDown do begin
  852.             GetMouse(mouse);
  853.             newinside := PtInRgn(mouse,rgn);
  854.             if newinside <> inside then begin
  855.                 InvertRgn(rgn);
  856.                 inside := newinside;
  857.             end;
  858.         end;
  859.         if inside then begin
  860.             InvertRgn(rgn);
  861.         end;
  862.         TrackItems := inside;
  863.     end;
  864.  
  865.     procedure DrawStyledTextUserItem( window: DialogPtr; item: integer; ft: MyFontType; face: Style; const data: Str255 );
  866.         var
  867.             box: Rect;
  868.             fi: FontInfo;
  869.             saved: SavedWindowInfo;
  870.     begin
  871.         Assert( window <> nil );
  872.         SetPort( window );
  873.         EnterWindow ( window, ft, face, saved );
  874.         GetDItemRect( window, item, box );
  875.         GetFontInfo( fi );
  876.         MoveTo( box.left, box.top + fi.ascent );
  877.         EraseRect( box );
  878.         DrawString( data );
  879.         ExitWindow( saved );
  880.     end;
  881.  
  882.     procedure DisplayStyledString (window: DialogPtr; item: integer; s: Str255; selected: boolean);
  883.         var
  884.             box: Rect;
  885.             just: integer;
  886.             this: Str255;
  887.             font, size, i, j, def_font, def_size: integer;
  888.             st: Style;
  889.             fi: FontInfo;
  890.             fixsize: boolean;
  891.             oldfont, oldsize: integer;
  892.             oldface: Style;
  893.             hot: Boolean; { parse for <> and blue-underline them }
  894.             teh:TEHandle;
  895.             tsr:TextStyle;
  896.             pos_left, pos_right: integer;
  897.     begin
  898.         Assert( window <> nil );
  899.         SetPort(window);
  900.         oldfont := window^.txFont;
  901.         oldsize := window^.txSize;
  902.         oldface := window^.txFace;
  903.         GetMyFonts(MFT_Geneva9, def_font, def_size);
  904.         GetDItemRect(window, item, box);
  905.         if SplitAt(s, ':', this, s) then begin
  906.             hot := false;
  907.             fixsize := false;
  908.             if this = '' then begin
  909.                 font := def_font;
  910.             end else begin
  911.                 GetFNum(this, font);
  912.                 if font = 0 then begin
  913.                     fixsize := true;
  914.                     font := def_font;
  915.                 end;
  916.             end;
  917.             if SplitAt(s, ':', this, s) then begin
  918.                 if this = '' then begin
  919.                     size := def_size;
  920.                 end else begin
  921.                     size := StrToNum(this);
  922.                 end;
  923.                 if SplitAt(s, ':', this, s) then begin
  924.                     st := [];
  925.                     for i := 1 to length(this) do begin
  926.                         case this[i] of
  927.                             '0'..'7':begin
  928.                                 st := st + [StyleItem(ord(this[i]) - 48)];
  929.                             end;
  930.                             'H','h': begin
  931.                                 hot := true;
  932.                             end;
  933.                             otherwise begin
  934.                             end;
  935.                         end;
  936.                     end;
  937.                     if SplitAt(s, ':', this, s) then begin
  938.                         if this = '' then begin
  939.                             just := teJustLeft;
  940.                         end else begin
  941.                             just := StrToNum(this);
  942.                         end;
  943.                         TextFont(font);
  944.                         TextSize(size);
  945.                         TextFace(st);
  946.                         if fixsize then begin
  947.                             GetFontInfo(fi);
  948.                             while (fi.ascent + fi.descent > box.bottom - box.top) do begin
  949.                                 if size > 48 then begin
  950.                                     size := 48;
  951.                                 end else if size > 36 then begin
  952.                                     size := 36;
  953.                                 end else if size > 27 then begin
  954.                                     size := 27;
  955.                                 end else if size > 24 then begin
  956.                                     size := 24;
  957.                                 end else if size > 18 then begin
  958.                                     size := 18;
  959.                                 end else if size > 14 then begin
  960.                                     size := 14;
  961.                                 end else if size > 12 then begin
  962.                                     size := 12;
  963.                                 end else begin
  964.                                     size := 9;
  965.                                     TextSize(size);
  966.                                     leave;
  967.                                 end;
  968.                                 TextSize(size);
  969.                                 GetFontInfo(fi);
  970.                             end;
  971.                         end;
  972.  
  973.                         teh := TEStyleNew(box,box);
  974.                         if teh<>nil then begin
  975.                             case just of
  976.                                 teJustLeft: begin
  977.                                     pos_left := 0;
  978.                                     pos_right := length(s);
  979.                                     s := s + spc;
  980.                                 end;
  981.                                 teJustCenter: begin
  982.                                     pos_left := 1;
  983.                                     pos_right := length(s)+1;
  984.                                     s := spc + s + spc;
  985.                                 end;
  986.                                 teJustRight: begin
  987.                                     pos_left := 1;
  988.                                     pos_right := length(s) + 1;
  989.                                     s := spc + s;
  990.                                 end;
  991.                             end;
  992.                             TESetText(@s[1],length(s),teh);
  993.                             TESetAlignment(just,teh);
  994.                             if hot then begin
  995.                                 for i := 1 to length(s) do begin
  996.                                     if s[i] = '<' then begin
  997.                                         j := i + 1;
  998.                                         while (j <= length(s)) & (s[j] <> '>') do begin
  999.                                             j := j + 1;
  1000.                                         end;
  1001.                                         TESetSelect(i,j-1,teh);
  1002.                                         tsr.tsFace := st + [underline];
  1003.                                         tsr.tsColor.red := 0;
  1004.                                         tsr.tsColor.green := 0;
  1005.                                         tsr.tsColor.blue := $FFFF;
  1006.                                         TESetStyle(doFace + doColor,tsr,false,teh);
  1007.                                     end;
  1008.                                 end;
  1009.                             end;
  1010.                             if selected then begin
  1011.                                 TESetSelect( pos_left, pos_right, teh );
  1012.                                 TEActivate( teh );
  1013.                             end;
  1014.                             TEUpdate(box,teh);
  1015.                             TEDispose(teh);
  1016.                         end;
  1017.  
  1018.                     end;
  1019.                 end;
  1020.             end;
  1021.         end;
  1022.         TextFont(oldfont);
  1023.         TextSize(oldsize);
  1024.         TextFace(oldface);
  1025.     end;
  1026.  
  1027.     function PointOverEditTextItem( window: WindowPtr; localwhere: Point ): integer;
  1028.         var
  1029.             item: integer;
  1030.             k: integer;
  1031.     begin
  1032.         Assert( window <> nil );
  1033.         item := FindDialogItem(window, localwhere) + 1;
  1034.         if item > 0 then begin
  1035.             GetDItemKind(window, item, k);
  1036.             if k <> editText then begin
  1037.                 item := 0;
  1038.             end;
  1039.         end;
  1040.         PointOverEditTextItem := item;
  1041.     end;
  1042.     
  1043.     function OverEditTextItem: Boolean;
  1044.         var
  1045.             window: WindowPtr;
  1046.             over: Boolean;
  1047.             localpt: Point;
  1048.     begin
  1049.         window := FrontWindow;
  1050.         over := false;
  1051.         if (window <> nil) & (WindowPeek(window)^.windowKind = kDialogWindowKind) then begin
  1052.             SetPort(window);
  1053.             GetMouse(localpt);
  1054.             over := PointOverEditTextItem( window, localpt ) > 0;
  1055.         end;
  1056.         OverEditTextItem := over;
  1057.     end;
  1058.     
  1059.     procedure DialogGetTextDropInformation( window: DialogPtr; localwhere: Point; var field: integer; var offset: integer; hilite: RgnHandle; invert: RgnHandle );
  1060.         procedure GetOffsetAndInsertionRect( te: TEHandle; localwhere: Point; var offset: integer; var insertion: Rect );
  1061.             var
  1062.                 basepoint: Point;
  1063.                 theStyle: TextStyle;
  1064.                 lineHeight: integer;
  1065.                 fontAscent: integer;
  1066.         begin
  1067.             offset := TEGetOffset( localwhere, te );
  1068.             basepoint := TEGetPoint( offset, te );
  1069.             TEGetStyle( offset, theStyle, lineHeight, fontAscent, te );
  1070.             insertion.left := basepoint.h;
  1071.             insertion.right := insertion.left + 2;
  1072.             insertion.bottom := basepoint.v;
  1073.             insertion.top := insertion.bottom - lineHeight;
  1074.         end;
  1075.         
  1076.         const
  1077.             v_offset = 5000;
  1078.         var
  1079.             field_contents: Str255;
  1080.             field_rect, insertion_rect: Rect;
  1081.             te: TEHandle;
  1082.             saved: SavedWindowInfo;
  1083.     begin
  1084.         field := PointOverEditTextItem( window, localwhere );
  1085.         if field > 0 then begin
  1086.             GetDItemRect( window, field, field_rect );
  1087.             InsetRect( field_rect, -2, -2 );
  1088.             RectRgn( hilite, field_rect );
  1089.             InsetRect( field_rect, 2, 2 );
  1090.             if SelectedTextItem( window ) = field then begin
  1091.                 GetOffsetAndInsertionRect( DialogPeek(window)^.textH, localwhere, offset, insertion_rect );                
  1092.             end else begin
  1093.                 { enter the window, set the font info }
  1094.                 EnterWindow( window, MFT_Geneva9, [], saved );
  1095.                 TextFont( DialogPeek(window)^.textH^^.txFont );
  1096.                 TextSize( DialogPeek(window)^.textH^^.txSize );
  1097.                 { put everything off the screen }
  1098.                 OffsetRect( field_rect, 0, v_offset);
  1099.                 localwhere.v := localwhere.v + v_offset;
  1100.                 { create a te rect and see where the mouse is }
  1101.                 te := TENew( field_rect, field_rect );
  1102.                 GetItemText( window, field, field_contents );
  1103.                 TESetText( @field_contents[1], length(field_contents), te );
  1104.                 GetOffsetAndInsertionRect( te, localwhere, offset, insertion_rect );
  1105.                 TEDispose( te );
  1106.                 { push the insertion rect back in to place }
  1107.                 OffsetRect( insertion_rect, 0, -v_offset);
  1108.                 { restore the state }
  1109.                 ExitWindow( saved );
  1110.             end;
  1111.             RectRgn( invert, insertion_rect );
  1112.         end;
  1113.     end;
  1114.     
  1115.     procedure StyleTextBox( text: Handle; styles: StScrpHandle; var box: Rect; just: integer);
  1116.         var
  1117.             te: TEHandle;
  1118.             r: Rect;
  1119.             saved_state: SignedByte;
  1120.     begin
  1121.         Assert( text <> nil );
  1122.         HLockState( text, saved_state );
  1123.         if styles = nil then begin
  1124.             TETextBox( text^, GetHandleSize(text), box, just);
  1125.         end else begin
  1126.             te := TEStyleNew( box, box );
  1127.             TEStyleInsert(text^, GetHandleSize(text), StScrpHandle(styles), te);
  1128.             TEUpdate(r, te);
  1129.             TEDispose(te);
  1130.         end;
  1131.         HSetState( text, saved_state );
  1132.     end;
  1133.  
  1134.     procedure SafePlotCIcon( id: integer; const frame: Rect; selected: boolean );
  1135.         var
  1136.             icon: CIconHandle;
  1137.             oldicon: Handle;
  1138.             junk: OSErr;
  1139.     begin
  1140.         if has_ColourQuickDraw then begin
  1141.             icon := GetCIcon( id );
  1142.             Assert( icon <> nil );
  1143.             if icon <> nil then begin
  1144.                 junk := PlotCIconHandle( frame, kAlignNone, Choose(selected, kTransformSelected, kTransformNone), icon );
  1145. {            Assert( junk = noErr );} { returns error in selected case - weird }
  1146.                 DisposeCIcon( icon );
  1147.             end;
  1148.         end else begin
  1149.             icon := CIconHandle(GetResource( 'cicn', id ));
  1150.             if icon <> nil then begin
  1151.                 HLock( Handle(icon) );
  1152.                 if (RectWidth( icon^^.iconMask.bounds ) = 32) & (RectHeight( icon^^.iconMask.bounds ) = 32)
  1153.                         & (RectWidth( icon^^.iconBMap.bounds ) = 32) & (RectHeight( icon^^.iconBMap.bounds ) = 32) 
  1154.                         & (icon^^.iconMask.rowBytes = 4) & (icon^^.iconBMap.rowBytes = 4) then begin
  1155.                     if MNewHandle( oldicon, 128 ) = noErr then begin
  1156.                         BlockMoveData( AddPtrLong( @icon^^.iconMaskData, 128 ), oldicon^, 128 );
  1157.                         PlotIcon( frame, oldicon );
  1158.                         if selected then begin
  1159.                             InvertRect( frame );
  1160.                         end;
  1161.                         MDisposeHandle( oldicon );
  1162.                     end;
  1163.                 end;
  1164.                 HUnlock( Handle(icon) );
  1165.                 HPurge( Handle(icon) );
  1166.             end;
  1167.         end;
  1168.     end;
  1169.  
  1170.     function InitMyDialogs(var msg: integer): OSStatus;
  1171.         var
  1172.             grey_colour: RGBColor;
  1173.             sysenv: SysEnvRec;
  1174.     begin
  1175. {$unused(msg)}
  1176.         DidStartup( startup_check );
  1177.         shutup_talking_alerts := false;
  1178.         gShutupTalkingAlertsModalFilterProc:=NewModalFilterProc(ShutupTalkingAlertsModalFilter);
  1179.         gStandardModalFilterProc:=NewModalFilterProc(StandardModalFilter);
  1180.         gCancelModalFilterProc:=NewModalFilterProc(CancelModalFilter);
  1181.         gDiscardModalFilterProc:=NewModalFilterProc(DiscardModalFilter);
  1182.         gOutlineDefault1Proc:=NewUserItemProc(OutlineDefault1);
  1183.         gOutlineDeviceLoopProc:=NewDeviceLoopDrawingProc(OutlineDeviceLoop);
  1184.         if (SysEnvirons(1, sysenv) = noErr) & sysenv.hasColorQD then begin
  1185.             grey_pattern := NewPixPat;
  1186.         end else begin
  1187.             grey_pattern := nil;
  1188.         end;
  1189.         if grey_pattern <> nil then begin
  1190.             MakeRGBColor($8000,$8000,$8000,grey_colour);
  1191.             MakeRGBPat(grey_pattern, grey_colour);
  1192.         end;
  1193.         InitMyDialogs := noErr;
  1194.     end;
  1195.  
  1196.     procedure StartupDialogs;
  1197.     begin
  1198.         SetStartup(InitMyDialogs, nil, 0, nil);
  1199.     end;
  1200.  
  1201. end.